#!/usr/bin/env node

const { execSync } = require('child_process');
const os = require('os');
const fs = require('fs');
const path = require('path');

console.log('正在检查可用的模拟器...');

// 检查Android模拟器
function checkAndroidEmulators() {
  try {
    console.log('\n=== Android模拟器 ===');
    let emulators = [];
    let hasRunningEmulator = false;
    
    // 首先检查是否有正在运行的模拟器或设备（优先方法，支持第三方模拟器）
    try {
      console.log('检查正在运行的模拟器/设备...');
      const devicesOutput = execSync('adb devices -l', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
      console.log('adb devices -l 输出:\n' + devicesOutput);
      const deviceLines = devicesOutput.trim().split('\n').slice(1); // 跳过标题行
      
      // 详细分析每一行设备信息，包括设备状态和描述
      const deviceDetails = [];
      deviceLines.forEach(line => {
        if (!line.trim()) return;
        
        const parts = line.trim().split(/\s+/);
        const deviceId = parts[0];
        const status = parts[1] || 'unknown';
        
        // 提取设备描述信息
        let description = '未知设备';
        const modelIndex = line.indexOf('model:');
        if (modelIndex > -1) {
          description = line.substring(modelIndex).split(' ')[0].replace('model:', '') || description;
        }
        
        deviceDetails.push({ id: deviceId, status: status, description: description });
      });
      
      if (deviceDetails.length > 0) {
        console.log(`找到 ${deviceDetails.length} 个设备/模拟器:`);
        deviceDetails.forEach((device, index) => {
          console.log(`${index + 1}. ID: ${device.id}, 状态: ${device.status}, 型号: ${device.description}`);
          
          // 对于第三方模拟器，状态可能不是标准的device
          if (device.status.includes('device') || 
              device.status.includes('emulator') || 
              device.status.includes('offline') || 
              device.status.includes('unauthorized')) {
            emulators.push(device.id);
          }
        });
        
        // 如果有任何设备被识别，即使状态不是完全正常，也认为有可用模拟器
        if (deviceDetails.length > 0) {
          hasRunningEmulator = true;
          // 如果没有通过严格过滤的设备，使用所有设备ID
          if (emulators.length === 0) {
            emulators = deviceDetails.map(d => d.id);
          }
        }
      } else {
        console.log('没有检测到正在运行的设备或模拟器');
        
        // 尝试额外的adb命令来检测第三方模拟器
        try {
          console.log('尝试检测第三方模拟器（如BlueStacks、夜神等）...');
          // 检查常见的第三方模拟器端口
          const commonPorts = [5554, 5555, 5556, 5557, 5558, 5559, 7555];
          let foundThirdParty = false;
          
          for (const port of commonPorts) {
            try {
              // 尝试连接到常见端口
              execSync(`adb connect localhost:${port}`, { stdio: ['pipe', 'pipe', 'ignore'] });
              console.log(`尝试连接到端口 ${port}...`);
            } catch (e) {
              // 连接失败，继续尝试下一个端口
            }
          }
          
          // 重新检查设备列表
          const updatedDevices = execSync('adb devices', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
          if (updatedDevices !== devicesOutput) {
            console.log('重新检查设备列表后发现变化，可能连接到了第三方模拟器');
            console.log('更新后的设备列表:\n' + updatedDevices);
            foundThirdParty = true;
          }
          
          if (foundThirdParty) {
            console.log('提示：如果您使用第三方模拟器，请确保已正确配置ADB连接');
          }
        } catch (e) {
          console.log('尝试检测第三方模拟器时出错:', e.message);
        }
      }
    } catch (adbError) {
      console.log('adb命令不可用或执行失败:', adbError.message);
      console.log('提示：请确保Android SDK已正确安装并且adb已添加到系统PATH');
      console.log('对于第三方模拟器，请确保已正确配置ADB连接设置');
    }
    
    // 如果没有运行中的设备，检查已安装的模拟器
    if (!hasRunningEmulator) {
      // 方法1：尝试使用emulator -list-avds命令
      try {
        console.log('检查已安装的Android模拟器...');
        let emulatorOutput = '';
        try {
          // 捕获stdout，但忽略stderr以避免日志干扰
          emulatorOutput = execSync('emulator -list-avds', { 
            encoding: 'utf8', 
            stdio: ['pipe', 'pipe', 'ignore']
          });
        } catch (e) {
          // 即使有错误，也尝试使用stdout
          if (e.stdout) {
            emulatorOutput = e.stdout;
          }
        }
        
        console.log('emulator -list-avds 原始输出:\n' + emulatorOutput);
        
        // 优化过滤逻辑，确保只识别真正的模拟器名称
        const lines = emulatorOutput.trim().split('\n');
        const potentialEmulators = lines
          .map(line => line.trim())
          .filter(line => {
            if (!line || line.length === 0) return false;
            
            const lowerLine = line.toLowerCase();
            
            // 过滤掉明显是日志的行
            if (lowerLine.startsWith('info') || 
                lowerLine.startsWith('warning') || 
                lowerLine.startsWith('error') ||
                lowerLine.includes('crashpadlogsink') ||
                lowerLine.includes('registered') ||
                lowerLine.includes('error messages') ||
                line.includes('|')) {
              return false;
            }
            
            // 模拟器名称通常是简单的标识符，不包含空格或特殊字符
            // 但为了支持更多情况，我们保留包含下划线、连字符和数字的名称
            return true;
          });
        
        if (potentialEmulators.length > 0) {
          emulators = potentialEmulators;
          console.log(`找到 ${emulators.length} 个已安装的Android模拟器:`);
          emulators.forEach((emulator, index) => {
            console.log(`${index + 1}. ${emulator}`);
          });
        } else {
          console.log('emulator命令输出中没有检测到有效的模拟器名称');
        }
      } catch (e) {
        console.log('emulator命令执行失败:', e.message);
      }
      
      // 方法2：检查AVD目录
      try {
        const homeDir = os.homedir();
        const avdDir = path.join(homeDir, '.android', 'avd');
        console.log(`检查AVD目录: ${avdDir}`);
        
        if (fs.existsSync(avdDir)) {
          const files = fs.readdirSync(avdDir);
          console.log(`AVD目录中的文件数量: ${files.length}`);
          
          if (files.length > 0) {
            const avdFiles = files.filter(file => file.endsWith('.avd') || file.endsWith('.ini'));
            console.log(`找到 ${avdFiles.length} 个AVD配置文件`);
            
            if (avdFiles.length > 0) {
              const avdNames = avdFiles
                .map(file => file.replace(/\.(avd|ini)$/, ''))
                .filter((value, index, self) => self.indexOf(value) === index); // 去重
              
              if (avdNames.length > 0 && emulators.length === 0) {
                emulators = avdNames;
                console.log(`从AVD目录找到 ${emulators.length} 个模拟器配置:`);
                emulators.forEach((emulator, index) => {
                  console.log(`${index + 1}. ${emulator}`);
                });
              }
            }
          } else {
            console.log('AVD目录存在但为空，没有已安装的模拟器');
          }
        } else {
          console.log('AVD目录不存在');
        }
      } catch (innerError) {
        console.log('读取AVD目录失败:', innerError.message);
      }
    }
    
    // 结果处理
    if (emulators.length > 0) {
      return true;
    } else {
      console.log('未找到可用的Android模拟器');
      console.log('提示：要创建Android模拟器，请使用Android Studio的AVD Manager');
      console.log('\n=== 第三方模拟器连接指南 ===');
      console.log('1. BlueStacks: 确保已启用"Android调试桥(ADB)"，通常在设置中');
      console.log('   端口通常为5555，可使用命令: adb connect localhost:5555');
      console.log('2. 夜神模拟器: 默认端口为62001，可使用命令: adb connect localhost:62001');
      console.log('3. 逍遥模拟器: 默认端口为21503，可使用命令: adb connect localhost:21503');
      console.log('4. 雷电模拟器: 默认端口为5555，可使用命令: adb connect localhost:5555');
      console.log('\n连接后，请再次运行此检查脚本');
      
      // 额外检查adb是否能正常工作，这对第三方模拟器很重要
      try {
        const adbVersion = execSync('adb version', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
        console.log('ADB版本信息:', adbVersion.trim());
      } catch (e) {
        console.log('警告：ADB可能未正确安装或未添加到系统PATH');
      }
      return false;
    }
  } catch (error) {
    console.error('检查Android模拟器时发生错误:', error.message);
    return false;
  }
}

// 检查iOS模拟器
function checkIOSSimulators() {
  try {
    // 只在macOS上检查iOS模拟器
    if (os.platform() !== 'darwin') {
      console.log('\n=== iOS模拟器 ===');
      console.log('当前操作系统不是macOS，无法检查iOS模拟器');
      return false;
    }
    
    console.log('\n=== iOS模拟器 ===');
    const output = execSync('xcrun simctl list devices available', { encoding: 'utf8', stdio: 'pipe' });
    
    // 解析输出，查找可用的模拟器
    const lines = output.trim().split('\n');
    const simulators = [];
    
    lines.forEach(line => {
      if (line.includes('(available)')) {
        const simulatorInfo = line.trim().split('(')[0].trim();
        if (simulatorInfo) {
          simulators.push(simulatorInfo);
        }
      }
    });
    
    if (simulators.length === 0) {
      console.log('未找到可用的iOS模拟器');
      return false;
    } else {
      console.log(`找到 ${simulators.length} 个可用的iOS模拟器:`);
      simulators.forEach((simulator, index) => {
        console.log(`${index + 1}. ${simulator}`);
      });
      return true;
    }
  } catch (error) {
    console.error('检查iOS模拟器时出错:', error.message);
    return false;
  }
}

// 检查已连接的设备
function checkConnectedDevices() {
  try {
    console.log('\n=== 已连接的设备 ===');
    
    // 检查Android设备 - 改进检测逻辑以支持第三方模拟器
    let androidDevices = [];
    try {
      const androidOutput = execSync('adb devices', { encoding: 'utf8', stdio: 'pipe' });
      console.log('adb devices 详细输出:\n' + androidOutput);
      const androidLines = androidOutput.trim().split('\n');
      androidDevices = androidLines
        .slice(1) // 跳过标题行
        .map(line => line.trim())
        .filter(line => {
          if (!line) return false;
          // 更宽松地检测各种设备状态，包括第三方模拟器
          return line.includes('device') || 
                 line.includes('emulator') || 
                 line.includes('offline') || 
                 line.includes('unauthorized');
        })
        .map(line => line.split('\t')[0]);
    } catch (e) {
      console.log('adb命令执行出错:', e.message);
    }
    
    // 检查iOS设备（仅在macOS上）
    let iosDevices = [];
    if (os.platform() === 'darwin') {
      try {
        const iosOutput = execSync('idevice_id -l', { encoding: 'utf8', stdio: 'pipe' });
        iosDevices = iosOutput.trim().split('\n').filter(id => id.trim());
      } catch (e) {
        // idevice_id可能不可用
      }
    }
    
    const totalDevices = androidDevices.length + iosDevices.length;
    
    if (totalDevices === 0) {
      console.log('未找到已连接的设备');
      return false;
    } else {
      console.log(`找到 ${totalDevices} 个已连接的设备:`);
      
      if (androidDevices.length > 0) {
        console.log('Android设备:');
        androidDevices.forEach((device, index) => {
          console.log(`  ${index + 1}. ${device}`);
        });
      }
      
      if (iosDevices.length > 0) {
        console.log('iOS设备:');
        iosDevices.forEach((device, index) => {
          console.log(`  ${index + 1}. ${device}`);
        });
      }
      
      return true;
    }
  } catch (error) {
    console.error('检查已连接设备时出错:', error.message);
    return false;
  }
}

// 主函数
function main() {
  const hasAndroidEmulators = checkAndroidEmulators();
  const hasIOSSimulators = checkIOSSimulators();
  const hasConnectedDevices = checkConnectedDevices();
  
  console.log('\n=== 检查结果摘要 ===');
  console.log(`Android模拟器: ${hasAndroidEmulators ? '可用' : '不可用'}`);
  console.log(`iOS模拟器: ${hasIOSSimulators ? '可用' : '不可用'}`);
  console.log(`已连接设备: ${hasConnectedDevices ? '可用' : '不可用'}`);
  
  const hasAvailableEmulatorsOrDevices = hasAndroidEmulators || hasIOSSimulators || hasConnectedDevices;
  
  if (hasAvailableEmulatorsOrDevices) {
    console.log('\n✓ 可以启动应用程序，有可用的模拟器或设备。');
    process.exit(0);
  } else {
    console.log('\n✗ 无法启动应用程序，没有找到可用的模拟器或设备。');
    console.log('请先创建或启动一个模拟器，或者连接一个实际设备。');
    process.exit(1);
  }
}

// 运行主函数
main();